package com.monitor.filter;

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Pattern;

/**
 * 关键字过滤器，用于检测文本中的敏感关键字
 */
public class KeywordFilter implements ContentFilter {
    private FilterSensitivity sensitivity = FilterSensitivity.HIGH;
    private List<String> blacklist = new ArrayList<>();
    private List<String> whitelist = new ArrayList<>();
    
    public KeywordFilter() {
        // 初始化默认黑白名单
        initDefaultLists();
    }
    
    public KeywordFilter(List<String> keywordBlacklist) {
        // 使用外部提供的关键词黑名单初始化
        initDefaultLists(keywordBlacklist);
    }
    
    private void initDefaultLists() {
        // 添加一些默认的敏感关键字
        blacklist.add("暴力");
        blacklist.add("色情");
        blacklist.add("赌博");
        blacklist.add("毒品");
        blacklist.add("恐怖");
        
        // 添加一些默认的白名单关键字
        whitelist.add("学习");
        whitelist.add("教育");
        whitelist.add("科学");
    }
    
    private void initDefaultLists(List<String> keywordBlacklist) {
        // 从外部数据源添加关键字到黑名单
        if (keywordBlacklist != null && !keywordBlacklist.isEmpty()) {
            blacklist.addAll(keywordBlacklist);
        } else {
            // 如果外部数据为空，使用默认关键字
            initDefaultLists();
        }
        
        // 添加一些默认的白名单关键字
        whitelist.add("学习");
        whitelist.add("教育");
        whitelist.add("科学");
    }
    
    @Override
    public boolean containsInappropriateContent(String content) {
        if (content == null || content.isEmpty()) {
            return false;
        }
        
        // 转换为小写进行匹配
        String lowerContent = content.toLowerCase();
        
        // 首先检查白名单
        for (String whiteKeyword : whitelist) {
            if (lowerContent.contains(whiteKeyword.toLowerCase())) {
                return false; // 在白名单中，直接放行
            }
        }
        
        // 根据灵敏度级别调整匹配策略
        switch (sensitivity) {
            case HIGH:
                return highSensitivityCheck(lowerContent);
            case MEDIUM:
                return mediumSensitivityCheck(lowerContent);
            case LOW:
                return lowSensitivityCheck(lowerContent);
            default:
                return mediumSensitivityCheck(lowerContent);
        }
    }
    
    private boolean highSensitivityCheck(String content) {
        // 高灵敏度：部分匹配即可，包括变形词
        for (String keyword : blacklist) {
            String lowerKeyword = keyword.toLowerCase();
            
            // 直接包含检查
            if (content.contains(lowerKeyword)) {
                return true;
            }
            
            // 检查变形词（用数字、符号替换字母）
            if (containsVariations(content, lowerKeyword)) {
                return true;
            }
        }
        return false;
    }
    
    private boolean mediumSensitivityCheck(String content) {
        // 中灵敏度：完整词匹配
        for (String keyword : blacklist) {
            String lowerKeyword = keyword.toLowerCase();
            
            // 使用正则表达式进行完整词匹配
            Pattern pattern = Pattern.compile("\\b" + Pattern.quote(lowerKeyword) + "\\b");
            if (pattern.matcher(content).find()) {
                return true;
            }
        }
        return false;
    }
    
    private boolean lowSensitivityCheck(String content) {
        // 低灵敏度：严格匹配，需要完全一致
        String[] words = content.split("\\s+");
        for (String word : words) {
            for (String keyword : blacklist) {
                if (word.equals(keyword.toLowerCase())) {
                    return true;
                }
            }
        }
        return false;
    }
    
    /**
     * 检查是否包含关键字的变形
     */
    private boolean containsVariations(String content, String keyword) {
        // 创建可能的变形模式
        String variation1 = keyword.replace("a", "@").replace("o", "0").replace("i", "1").replace("s", "$");
        String variation2 = keyword.replace("a", "4").replace("e", "3").replace("l", "1").replace("t", "7");
        
        return content.contains(variation1) || content.contains(variation2);
    }
    
    @Override
    public String getFilterName() {
        return "关键字过滤器";
    }
    
    @Override
    public String getFilterDescription() {
        return "基于预置的关键字黑名单库检测文本中的敏感内容";
    }
    
    @Override
    public void setSensitivity(FilterSensitivity sensitivity) {
        this.sensitivity = sensitivity;
    }
    
    @Override
    public FilterSensitivity getSensitivity() {
        return sensitivity;
    }
    
    /**
     * 添加关键字到黑名单
     */
    public void addToBlacklist(String keyword) {
        if (keyword != null && !keyword.trim().isEmpty() && !blacklist.contains(keyword.trim())) {
            blacklist.add(keyword.trim());
        }
    }
    
    /**
     * 从黑名单中移除关键字
     */
    public void removeFromBlacklist(String keyword) {
        blacklist.remove(keyword);
    }
    
    /**
     * 更新黑名单
     */
    public void updateBlacklist(List<String> newBlacklist) {
        this.blacklist.clear();
        if (newBlacklist != null) {
            for (String keyword : newBlacklist) {
                addToBlacklist(keyword);
            }
        }
    }
    
    /**
     * 获取当前黑名单
     */
    public List<String> getBlacklist() {
        return new ArrayList<>(blacklist);
    }
    
    /**
     * 添加关键字到白名单
     */
    public void addToWhitelist(String keyword) {
        if (keyword != null && !keyword.trim().isEmpty() && !whitelist.contains(keyword.trim())) {
            whitelist.add(keyword.trim());
        }
    }
    
    /**
     * 从白名单中移除关键字
     */
    public void removeFromWhitelist(String keyword) {
        whitelist.remove(keyword);
    }
    
    /**
     * 获取当前白名单
     */
    public List<String> getWhitelist() {
        return new ArrayList<>(whitelist);
    }
    
    /**
     * 清空黑名单
     */
    public void clearBlacklist() {
        blacklist.clear();
    }
    
    /**
     * 清空白名单
     */
    public void clearWhitelist() {
        whitelist.clear();
    }
}